home *** CD-ROM | disk | FTP | other *** search
/ NOVA - For the NeXT Workstation / NOVA - For the NeXT Workstation.iso / Apps / Graphics / Converters / jpeg / giflib.c < prev    next >
C/C++ Source or Header  |  1992-12-25  |  8KB  |  337 lines
  1. /*
  2. Copyright Notice:
  3.     Copyright 1990 Robert C. Hood
  4.     This software is distributed "as is" without warranty.  Use this software at your OWN RISK.  Source may be distributed freely, at NO CHARGE, but must be accompanied by this documentation and copyright notice.
  5. */
  6. /*
  7. Copyright Notice:
  8.     Copyright 1990 Robert C. Hood
  9.     This software is distributed "as is" without warranty.  Use this software at your OWN RISK.  Source may be distributed freely, at NO CHARGE, but must be accompanied by this documentation and copyright notice.
  10. */
  11. #define mem_getc(x)    ((int) *(pos++))
  12.  
  13. unsigned char *pos;
  14. volatile unsigned char *file_buf;
  15.  
  16.  
  17.  
  18. #include <stdio.h>
  19. #include "giflib.h"
  20.  
  21.  
  22. inline  startbuffer (size)
  23. int size;
  24.     {
  25.     unsigned char *p;
  26.     
  27.     GIF_max = size;
  28.     
  29.     for (p = GIF_buffer; size > 0; size --)
  30.         *(p++) = mem_getc(dum);
  31.     
  32. //    fread (&GIF_buffer, 1, size, GIF_file);
  33.     GIF_bufptr = 0;
  34.     GIF_bitbuffer = ((unsigned int)GIF_buffer [GIF_bufptr]) |
  35.         ((unsigned int)GIF_buffer [GIF_bufptr + 1] << 8) |
  36.         ((unsigned int)GIF_buffer [GIF_bufptr + 2] << 16) |
  37.         ((unsigned int)GIF_buffer [GIF_bufptr + 3] << 24);
  38.     GIF_bufptr += 4;
  39.     GIF_bits = 0;
  40.     }
  41.  
  42. inline  getbits (num)
  43. register int num;
  44.     {
  45.     register int reply;
  46.     register unsigned int temp;
  47.  
  48.     reply = (0xFFFFFFFF >> (32 - num)) & GIF_bitbuffer;
  49.     GIF_bitbuffer = GIF_bitbuffer >> num;
  50.     GIF_bits += num;
  51.     while (GIF_bits >= 16)
  52.         {
  53.         temp = (unsigned int)GIF_buffer [GIF_bufptr++];
  54.         temp |= (unsigned int)GIF_buffer [GIF_bufptr++] << 8;
  55.         GIF_bitbuffer |= ((unsigned int)temp << (32 - GIF_bits));
  56.         GIF_bits -= 16;
  57.         }
  58.     return reply;
  59.     }
  60.  
  61.     
  62. readgifheader (int size)
  63.     {
  64.     file_buf = malloc(size);
  65.     fread(file_buf, size, 1, GIF_file);
  66.     
  67.     pos = file_buf;
  68.     
  69.     if (getsig () < 0)
  70.         return -1;
  71.     if (getdesc () < 0)
  72.         return -1;
  73.     if (getgcmap () < 0)
  74.         return -1;
  75.     if (getidesc () < 0)
  76.         return -1;
  77.     return 0;
  78.     }
  79.     
  80. readgif ()
  81.     {
  82.     int loop;
  83.     
  84.     GIF_curx = 0;
  85.     GIF_cury = 0;
  86.     GIF_ytemp = 8;
  87.     GIF_ystart = 0;
  88.     r = (unsigned char *)malloc (GIF_ysize * GIF_xsize);
  89.     g = (unsigned char *)malloc (GIF_ysize * GIF_xsize);
  90.     b = (unsigned char *)malloc (GIF_ysize * GIF_xsize);
  91.     for (loop = 0; loop < (GIF_ysize * GIF_xsize); ++loop)
  92.         {
  93.         r [loop] = GIF_globalmap [GIF_background * 3];
  94.         b [loop] = GIF_globalmap [GIF_background * 3 + 1];
  95.         g [loop] = GIF_globalmap [GIF_background * 3 + 2];
  96.         }
  97.     if ((r == 0) || (g == 0) || (b == 0))
  98.         return -1;
  99.     loop = getimage ();
  100.     free (GIF_globalmap);
  101.     free (file_buf);
  102.     return loop;
  103.     }
  104.     
  105. getsig  ()
  106.     {
  107.     if (((char)mem_getc (GIF_file) != 'G') || ((char)mem_getc (GIF_file) != 'I') || 
  108.         ((char)mem_getc (GIF_file) != 'F') || ((char)mem_getc (GIF_file) != '8') || 
  109.         ((char)mem_getc (GIF_file) != '7') || ((char)mem_getc (GIF_file) != 'a'))
  110.         return (-1);
  111.     return 0;
  112.     }    
  113.  
  114. getdesc ()
  115.     {
  116.     unsigned char temp;
  117.  
  118.     GIF_swidth = (int)mem_getc (GIF_file);
  119.     GIF_swidth += ((int)mem_getc (GIF_file) << 8);
  120.     GIF_sheight = (int)mem_getc (GIF_file);
  121.     GIF_sheight += ((int)mem_getc (GIF_file) << 8);
  122.     temp = (unsigned char)mem_getc (GIF_file);
  123.     GIF_gmap = temp >> 7;
  124.     GIF_colorres = (temp >> 4) & 7;
  125.     GIF_gbits = temp & 7;
  126.     GIF_background = mem_getc (GIF_file);
  127.     if (mem_getc (GIF_file) != 0)
  128.         return (-1);
  129.     return 0;
  130.     }
  131.     
  132. getgcmap ()
  133.     {
  134.     int size, loop;
  135.     unsigned char *ptr;
  136.     
  137.     if (GIF_gmap)
  138.         {
  139.         size = 1 << (GIF_gbits + 1);
  140.         if ((GIF_globalmap = (unsigned char *)malloc (sizeof (char) * size * 3)) == 0)
  141.             return -1;
  142.         ptr = GIF_globalmap;
  143.         for (loop = 0; loop < size * 3; ++loop)
  144.                     *(ptr++) = mem_getc (GIF_file);
  145.         }
  146.     else
  147.         {
  148.         GIF_globalmap = 0;
  149.         }
  150.     return 0;
  151.     }
  152.  
  153. getidesc ()
  154.     {
  155.     unsigned char temp;
  156.  
  157.     while ((char)mem_getc (GIF_file) != ',')
  158.         ;
  159.     GIF_xpos = (int)mem_getc (GIF_file);
  160.     GIF_xpos += ((int)mem_getc (GIF_file) << 8);
  161.     GIF_ypos = (int)mem_getc (GIF_file);
  162.     GIF_ypos += ((int)mem_getc (GIF_file) << 8);
  163.     GIF_xsize = (int)mem_getc (GIF_file);
  164.     GIF_xsize += ((int)mem_getc (GIF_file) << 8);
  165.     GIF_ysize = (int)mem_getc (GIF_file);
  166.     GIF_ysize += ((int)mem_getc (GIF_file) << 8);
  167.     temp = mem_getc (GIF_file);
  168.     GIF_lmap = temp >> 7;
  169.     GIF_interlaced = (temp >> 6) & 1;
  170.     GIF_lbits = temp & 7;
  171.     return 0;
  172.     }
  173.  
  174. unsigned short *table [4096];
  175. char hex [] = "0123456789abcdef";
  176.  
  177. output (code, bits)
  178. int code, bits;
  179.     {
  180.     register int loop;
  181.     unsigned char *ptr;
  182.     unsigned short *p;
  183.     register unsigned char temp;
  184.     static char lastcode = 0;
  185.     char output [7], *i;
  186.     
  187.     p = table [code];
  188.     for (loop = 1; loop < ((int)*p + 1); ++loop)
  189.         {
  190.         ptr = GIF_globalmap + *(p + loop) * 3;
  191.         *(r + (GIF_cury * GIF_xsize) + GIF_curx) = *ptr;
  192.         *(g + (GIF_cury * GIF_xsize) + GIF_curx) = *(ptr + 1);
  193.         *(b + (GIF_cury * GIF_xsize) + GIF_curx) = *(ptr + 2);
  194.         if ((++(GIF_curx)) == GIF_xsize)
  195.             {
  196.             GIF_curx = 0;
  197.             if (GIF_interlaced == 0)
  198.                 ++GIF_cury;
  199.             else
  200.                 {
  201.                 GIF_cury += GIF_ytemp;
  202.                 if (GIF_cury >= GIF_ysize)
  203.                     {
  204.                     ++GIF_ystart;
  205.                     switch (GIF_ystart)
  206.                         {
  207.                         case 1:
  208.                             GIF_ytemp = 8;
  209.                             GIF_cury = 4;
  210.                             break;
  211.                         case 2:
  212.                             GIF_ytemp = 4;
  213.                             GIF_cury = 2;
  214.                             break;
  215.                         case 3:
  216.                             GIF_ytemp = 2;
  217.                             GIF_cury = 1;
  218.                             break;
  219.                         }
  220.                     }
  221.                 }
  222.             }
  223.         }
  224.     }
  225.     
  226. getimage ()
  227.     {
  228.     unsigned int first, data, bits, dsize, csize, clear, eod, maxcode, nextcode, oldcode;
  229.     register unsigned int totalbits, maxbits, loop, done;
  230.     unsigned int buffer [4097];
  231.     
  232.     
  233.     csize = mem_getc (GIF_file);
  234.     bits = csize + 1;
  235.     for (loop = 0; loop < (1 << csize); ++ loop)
  236.         {
  237.         table [loop] = (unsigned short *)malloc (sizeof (unsigned short) * 2);
  238.         *table [loop] = 1;
  239.         *(table [loop] + 1) = (unsigned char)loop;
  240.         }
  241.         
  242.     dsize = mem_getc (GIF_file);
  243.     startbuffer (dsize);
  244.     totalbits = 0;
  245.     maxbits = dsize * 8;
  246.     clear = 1 << csize;
  247.     eod = clear + 1;
  248.     nextcode = eod + 1;
  249.     maxcode = (1 << bits) - 1;
  250.     done = 0;
  251.     first = 1;
  252.     while (!done)
  253.         {
  254.         if ((totalbits + bits) >= maxbits)
  255.             {
  256. //            data = getbits (maxbits - totalbits) << (bits - (maxbits - totalbits));
  257.             data = getbits (maxbits - totalbits); 
  258.             dsize = mem_getc (GIF_file);
  259.             startbuffer (dsize);
  260.             data += (getbits (bits - (maxbits - totalbits)) << (maxbits - totalbits));
  261.             totalbits = (bits - (maxbits - totalbits));
  262.             maxbits = dsize * 8;
  263.             }
  264.         else
  265.             {
  266.             data = getbits (bits);
  267.             totalbits += bits;
  268.             }
  269.         if (data == clear)
  270.             {
  271.             bits = csize + 1;
  272.             for (loop = clear + 2; loop < nextcode; ++loop)
  273.                 free (table [loop]);
  274.             nextcode = clear + 2;
  275.             maxcode = (1 << bits) - 1;
  276.             first = 1;
  277.             }
  278.         else if (data == eod)
  279.             {
  280.             done = 1;
  281.             }
  282.         else if (first == 1)
  283.             {
  284.             first = 0;
  285.             output (data, clear);
  286.             oldcode = data;
  287.             }
  288.         else if (data < nextcode)
  289.             {
  290.             output (data, clear);
  291.             table [nextcode] = (unsigned short *)malloc (sizeof (unsigned short) * (*table [oldcode] + 2));
  292.             for (loop = 1; loop < ((int)*table [oldcode] + 1); ++loop)
  293.                 *(table [nextcode] + loop) = *(table [oldcode] + loop);
  294.             *table [nextcode] = *table [oldcode] + 1;
  295.             *(table [nextcode] + *table [nextcode]) = *(table [data] + 1);
  296.             ++nextcode;
  297.             if (nextcode > maxcode)
  298.                 {
  299.                 if (nextcode != 4096)
  300.                     {
  301.                     ++bits;
  302.                     maxcode = (1 << bits) - 1;
  303.                     }
  304.                 }
  305.             oldcode = data;
  306.             }
  307.         else if (data == nextcode)
  308.             {
  309.             table [nextcode] = (unsigned short *)malloc (sizeof (unsigned short) * 
  310.                 (*table [oldcode] + 2));
  311.             for (loop = 1; loop < ((int)*table [oldcode] + 1); ++loop)
  312.                 *(table [nextcode] + loop) = *(table [oldcode] + loop);
  313.             *table [nextcode] = *table [oldcode] + 1;
  314.             *(table [nextcode] + *table [nextcode]) = *(table [oldcode]+1);
  315.             output (nextcode, clear);
  316.             ++nextcode;
  317.             if (nextcode > maxcode)
  318.                 {
  319.                 if (nextcode != 4096)
  320.                     {
  321.                     ++bits;
  322.                     maxcode = (1 << bits) - 1;
  323.                     }
  324.                 }
  325.             oldcode = data;
  326.             }
  327.         else /* BAD */
  328.             {
  329.             return (-1);
  330.             }
  331.         }
  332.     for (loop = clear + 2; loop < nextcode; ++loop)
  333.         free (table [loop]);
  334.     return 0;
  335.     }
  336.     
  337.